parsers.js ➔ parseRGB - Code Metrics - HuasoFoundries/ig_markerfactory - Measure and Improve Code Quality continuously with Scrutinizer

parsers.js ➔ parseRGB A
last analyzed 2018-11-12 22:15 UTC

↳ Parent: src/parsers.js

Complexity

Conditions	3
Paths	8

Size

Total Lines	32
Code Lines	25

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	3
eloc	25
nc	8
nop	3
dl	0
loc	32
rs	9.28
c	0
b	0
f	0

/** global: google, r, g, b */

import { hslaString, rgbaString, parseHalf, compact } from "./helpers.js";

export function parseHex(hexstring, opacity, darkenfactor) {
    let hexcolor = {
        hex: hexstring
    };
    darkenfactor = darkenfactor || 1;

    hexstring = hexstring.replace("#", "");
    if (hexstring.length === 3) {
        hexstring =
            hexstring[0] +
            hexstring[0] +
            hexstring[1] +
            hexstring[1] +
            hexstring[2] +
            hexstring[2];
    }
    if (isNaN(parseFloat(opacity, 10))) {
        opacity = 1;
    }

    hexcolor.r = parseInt(
        darkenfactor * parseInt(hexstring.substring(0, 2), 16),
        10
    );
    hexcolor.g = parseInt(
        darkenfactor * parseInt(hexstring.substring(2, 4), 16),
        10
    );
    hexcolor.b = parseInt(
        darkenfactor * parseInt(hexstring.substring(4, 6), 16),
        10
    );
    hexcolor.a = opacity;
    hexcolor.fillColor = rgbaString(hexcolor);
    hexcolor.strokeColor = [
        "rgba(" + parseHalf(hexcolor.r),
        parseHalf(hexcolor.g),
        parseHalf(hexcolor.b),
        hexcolor.a + ")"
    ].join(",");
    hexcolor.rgb = hexcolor.fillColor;
    return hexcolor;
}

export function parseHSL(hslstring, opacity) {
    let hslcolor = {},
        hslcolor_stroke = {},
        hslparts = compact(hslstring.split(/hsla?\(|,|\)|%/));

    if (hslparts[3] === undefined) {
        hslparts[3] = 1;
    }
    if (isNaN(parseFloat(opacity, 10))) {
        opacity = 1;
    }

    hslcolor.h = hslcolor_stroke.h = parseFloat(hslparts[0], 10);
    hslcolor.s = hslcolor_stroke.s = parseFloat(hslparts[1], 10);
    hslcolor.l = parseFloat(hslparts[2], 10);
    hslcolor.a = hslcolor_stroke.a = parseFloat(opacity * hslparts[3], 10);
    hslcolor_stroke.l = parseInt(hslcolor.l / 2, 10);

    hslcolor.fillColor = hslaString(hslcolor);
    hslcolor.strokeColor = hslaString(hslcolor_stroke);
    hslcolor.hsl = hslcolor.fillColor;
    return hslcolor;
}

export function parseRGB(rgbstring, opacity, darkenfactor) {
    let rgbcolor = {},
        rgbparts = compact(rgbstring.split(/rgba?\(|,|\)/));

    darkenfactor = darkenfactor || 1;

    if (rgbparts[3] === undefined) {
        rgbparts[3] = 1;
    }

    if (isNaN(parseFloat(opacity, 10))) {
        opacity = 1;
    }

    rgbcolor.r = parseInt(darkenfactor * (parseInt(rgbparts[0], 10) % 256), 10);
    rgbcolor.g = parseInt(darkenfactor * (parseInt(rgbparts[1], 10) % 256), 10);
    rgbcolor.b = parseInt(darkenfactor * (parseInt(rgbparts[2], 10) % 256), 10);
    rgbcolor.a = parseFloat(opacity * rgbparts[3], 10);
    rgbcolor.fillColor = rgbaString(rgbcolor);
    rgbcolor.strokeColor =
        "rgba(" +
        rgbcolor.r / 2 +
        "," +
        rgbcolor.g / 2 +
        "," +
        rgbcolor.b / 2 +
        "," +
        rgbcolor.a +
        ")";
    rgbcolor.rgb = rgbcolor.fillColor;
    return rgbcolor;
}

function hue2rgb(p, q, t) {
    if (t < 0) {
        t += 1;
    }
    if (t > 1) {
        t -= 1;
    }
    if (t < 1 / 6) {
        return p + (q - p) * 6 * t;
    }
    if (t < 1 / 2) {
        return q;
    }
    if (t < 2 / 3) {
        return p + (q - p) * (2 / 3 - t) * 6;
    }
    return p;
}

export function hslToRGB(h, s, l, a, darkenfactor) {
    let r, g, b;

    darkenfactor = darkenfactor || 1;
    h = parseFloat(h, 10) / 360;
    s = parseFloat(s, 10) / 100;
    l = parseFloat(l, 10) / 100;
    if (a === undefined) {
        a = 1;
    }
    if (s === 0) {
        r = g = b = l; // achromatic
    } else {
        let q = l < 0.5 ? l * (1 + s) : l + s - l * s;
        let p = 2 * l - q;
        r = hue2rgb(p, q, h + 1 / 3);
        g = hue2rgb(p, q, h);
        b = hue2rgb(p, q, h - 1 / 3);
    }

    if (a === undefined) {
        a = 1;
    }

    let rgb = {
        r: Math.round(r * 255 * darkenfactor),
        g: Math.round(g * 255 * darkenfactor),
        b: Math.round(b * 255 * darkenfactor),
        a: parseFloat(a, 10)
    };

    rgb.fillColor = rgbaString(rgb);

    return rgb;
}

export function rgbToHSL(in_r, in_g, in_b, in_a) {
    let h,
        r = (in_r % 256) / 255,
        g = (in_g % 256) / 255,
        b = (in_b % 256) / 255,
        a = in_a === undefined ? 1 : in_a,
        max = Math.max(r, g, b),
        min = Math.min(r, g, b),
        sum = max + min,
        diff = max - min,
        s = sum > 1 ? diff / (2 - sum) : diff / sum;

    switch (max) {
        case r:
            h = (g - b) / diff + (g < b ? 6 : 0);
            break;
        case g:
            h = (b - r) / diff + 2;
            break;
        case b:
            h = (r - g) / diff + 4;
            break;
        default:
            h = 0;
            break;
    }

    h /= 6;

    if (diff === 0) {
        h = s = 0; // achromatic
    }

    let hsl = {
        h: Math.round(360 * h),
        s: Math.round(100 * s),
        l: Math.round(50 * sum),
        a: Math.round(100 * a) / 100
    };

    hsl.fillColor = hslaString(hsl);

    return hsl;
}

function toDecColor(stringcolor) {
    let parsedcolor = {};
    if (!stringcolor) {
        parsedcolor.fillColor = "rgba(100,250,50,0.99)";
    } else if (stringcolor.indexOf("rgb") !== -1) {
        parsedcolor = parseRGB(stringcolor);
    } else if (stringcolor.indexOf("hsl") !== -1) {
        parsedcolor = parseHSL(stringcolor);
    } else {
        parsedcolor = parseHex(stringcolor);
    }

    return parsedcolor;
}

function getColor(val, range) {
    const defaults = {
        h: Math.floor((360 / range) * val),
        s: 78, // constant saturation
        l: 63, // constant luminance
        a: 1
    };

    return hslaString(defaults);
}

function getColor1() {
    const defaults1 = {
        h: 1,
        s: 78, // constant saturation
        l: 33, // constant luminance
        a: 1
    };
    return hslaString(defaults1);
}

function darken(stringcolor, factor) {
    const darkercolor = {};
    if (!factor) {
        factor = 1;
    }
    if (stringcolor.fillColor.indexOf("rgb") !== -1) {
        darkercolor.r = factor * parseHalf(stringcolor.r);
        darkercolor.g = factor * parseHalf(stringcolor.g);
        darkercolor.b = factor * parseHalf(stringcolor.b);
        darkercolor.a = 0.99;
        darkercolor.fillColor = rgbaString(darkercolor);
    } else if (stringcolor.fillColor.indexOf("hsl") !== -1) {
        darkercolor.h = stringcolor.h;
        darkercolor.s = stringcolor.s;
        darkercolor.l = factor * stringcolor.l - 30;
        darkercolor.fillColor = hslaString(darkercolor);
    }

    return darkercolor;
}

export function getColors(options) {
    let color0, color1;
    if (options.index !== undefined && options.count > 0) {
        color0 = getColor(options.index, options.count);
        color1 = getColor1();
    } else {
        let deccolor = toDecColor(options.color);
        color0 = deccolor.fillColor;
        color1 = darken(deccolor).fillColor;
    }
    return [color0, color1];
}


1			/** global: google, r, g, b */
2
3			import { hslaString, rgbaString, parseHalf, compact } from "./helpers.js";
4
5			export function parseHex(hexstring, opacity, darkenfactor) {
6			let hexcolor = {
7			hex: hexstring
8			};
9			darkenfactor = darkenfactor \|\| 1;
10
11			hexstring = hexstring.replace("#", "");
12			if (hexstring.length === 3) {
13			hexstring =
14			hexstring[0] +
15			hexstring[0] +
16			hexstring[1] +
17			hexstring[1] +
18			hexstring[2] +
19			hexstring[2];
20			}
21			if (isNaN(parseFloat(opacity, 10))) {
22			opacity = 1;
23			}
24
25			hexcolor.r = parseInt(
26			darkenfactor * parseInt(hexstring.substring(0, 2), 16),
27			10
28			);
29			hexcolor.g = parseInt(
30			darkenfactor * parseInt(hexstring.substring(2, 4), 16),
31			10
32			);
33			hexcolor.b = parseInt(
34			darkenfactor * parseInt(hexstring.substring(4, 6), 16),
35			10
36			);
37			hexcolor.a = opacity;
38			hexcolor.fillColor = rgbaString(hexcolor);
39			hexcolor.strokeColor = [
40			"rgba(" + parseHalf(hexcolor.r),
41			parseHalf(hexcolor.g),
42			parseHalf(hexcolor.b),
43			hexcolor.a + ")"
44			].join(",");
45			hexcolor.rgb = hexcolor.fillColor;
46			return hexcolor;
47			}
48
49			export function parseHSL(hslstring, opacity) {
50			let hslcolor = {},
51			hslcolor_stroke = {},
52			hslparts = compact(hslstring.split(/hsla?\(\|,\|\)\|%/));
53
54			if (hslparts[3] === undefined) {
55			hslparts[3] = 1;
56			}
57			if (isNaN(parseFloat(opacity, 10))) {
58			opacity = 1;
59			}
60
61			hslcolor.h = hslcolor_stroke.h = parseFloat(hslparts[0], 10);
62			hslcolor.s = hslcolor_stroke.s = parseFloat(hslparts[1], 10);
63			hslcolor.l = parseFloat(hslparts[2], 10);
64			hslcolor.a = hslcolor_stroke.a = parseFloat(opacity * hslparts[3], 10);
65			hslcolor_stroke.l = parseInt(hslcolor.l / 2, 10);
66
67			hslcolor.fillColor = hslaString(hslcolor);
68			hslcolor.strokeColor = hslaString(hslcolor_stroke);
69			hslcolor.hsl = hslcolor.fillColor;
70			return hslcolor;
71			}
72
73			export function parseRGB(rgbstring, opacity, darkenfactor) {
74			let rgbcolor = {},
75			rgbparts = compact(rgbstring.split(/rgba?\(\|,\|\)/));
76
77			darkenfactor = darkenfactor \|\| 1;
78
79			if (rgbparts[3] === undefined) {
80			rgbparts[3] = 1;
81			}
82
83			if (isNaN(parseFloat(opacity, 10))) {
84			opacity = 1;
85			}
86
87			rgbcolor.r = parseInt(darkenfactor * (parseInt(rgbparts[0], 10) % 256), 10);
88			rgbcolor.g = parseInt(darkenfactor * (parseInt(rgbparts[1], 10) % 256), 10);
89			rgbcolor.b = parseInt(darkenfactor * (parseInt(rgbparts[2], 10) % 256), 10);
90			rgbcolor.a = parseFloat(opacity * rgbparts[3], 10);
91			rgbcolor.fillColor = rgbaString(rgbcolor);
92			rgbcolor.strokeColor =
93			"rgba(" +
94			rgbcolor.r / 2 +
95			"," +
96			rgbcolor.g / 2 +
97			"," +
98			rgbcolor.b / 2 +
99			"," +
100			rgbcolor.a +
101			")";
102			rgbcolor.rgb = rgbcolor.fillColor;
103			return rgbcolor;
104			}
105
106			function hue2rgb(p, q, t) {
107			if (t < 0) {
108			t += 1;
109			}
110			if (t > 1) {
111			t -= 1;
112			}
113			if (t < 1 / 6) {
114			return p + (q - p) * 6 * t;
115			}
116			if (t < 1 / 2) {
117			return q;
118			}
119			if (t < 2 / 3) {
120			return p + (q - p) * (2 / 3 - t) * 6;
121			}
122			return p;
123			}
124
125			export function hslToRGB(h, s, l, a, darkenfactor) {
126			let r, g, b;
127
128			darkenfactor = darkenfactor \|\| 1;
129			h = parseFloat(h, 10) / 360;
130			s = parseFloat(s, 10) / 100;
131			l = parseFloat(l, 10) / 100;
132			if (a === undefined) {
133			a = 1;
134			}
135			if (s === 0) {
136			r = g = b = l; // achromatic
137			} else {
138			let q = l < 0.5 ? l * (1 + s) : l + s - l * s;
139			let p = 2 * l - q;
140			r = hue2rgb(p, q, h + 1 / 3);
141			g = hue2rgb(p, q, h);
142			b = hue2rgb(p, q, h - 1 / 3);
143			}
144
145			if (a === undefined) {
146			a = 1;
147			}
148
149			let rgb = {
150			r: Math.round(r * 255 * darkenfactor),
151			g: Math.round(g * 255 * darkenfactor),
152			b: Math.round(b * 255 * darkenfactor),
153			a: parseFloat(a, 10)
154			};
155
156			rgb.fillColor = rgbaString(rgb);
157
158			return rgb;
159			}
160
161			export function rgbToHSL(in_r, in_g, in_b, in_a) {
162			let h,
163			r = (in_r % 256) / 255,
164			g = (in_g % 256) / 255,
165			b = (in_b % 256) / 255,
166			a = in_a === undefined ? 1 : in_a,
167			max = Math.max(r, g, b),
168			min = Math.min(r, g, b),
169			sum = max + min,
170			diff = max - min,
171			s = sum > 1 ? diff / (2 - sum) : diff / sum;
172
173			switch (max) {
174			case r:
175			h = (g - b) / diff + (g < b ? 6 : 0);
176			break;
177			case g:
178			h = (b - r) / diff + 2;
179			break;
180			case b:
181			h = (r - g) / diff + 4;
182			break;
183			default:
184			h = 0;
185			break;
186			}
187
188			h /= 6;
189
190			if (diff === 0) {
191			h = s = 0; // achromatic
192			}
193
194			let hsl = {
195			h: Math.round(360 * h),
196			s: Math.round(100 * s),
197			l: Math.round(50 * sum),
198			a: Math.round(100 * a) / 100
199			};
200
201			hsl.fillColor = hslaString(hsl);
202
203			return hsl;
204			}
205
206			function toDecColor(stringcolor) {
207			let parsedcolor = {};
208			if (!stringcolor) {
209			parsedcolor.fillColor = "rgba(100,250,50,0.99)";
210			} else if (stringcolor.indexOf("rgb") !== -1) {
211			parsedcolor = parseRGB(stringcolor);
212			} else if (stringcolor.indexOf("hsl") !== -1) {
213			parsedcolor = parseHSL(stringcolor);
214			} else {
215			parsedcolor = parseHex(stringcolor);
216			}
217
218			return parsedcolor;
219			}
220
221			function getColor(val, range) {
222			const defaults = {
223			h: Math.floor((360 / range) * val),
224			s: 78, // constant saturation
225			l: 63, // constant luminance
226			a: 1
227			};
228
229			return hslaString(defaults);
230			}
231
232			function getColor1() {
233			const defaults1 = {
234			h: 1,
235			s: 78, // constant saturation
236			l: 33, // constant luminance
237			a: 1
238			};
239			return hslaString(defaults1);
240			}
241
242			function darken(stringcolor, factor) {
243			const darkercolor = {};
244			if (!factor) {
245			factor = 1;
246			}
247			if (stringcolor.fillColor.indexOf("rgb") !== -1) {
248			darkercolor.r = factor * parseHalf(stringcolor.r);
249			darkercolor.g = factor * parseHalf(stringcolor.g);
250			darkercolor.b = factor * parseHalf(stringcolor.b);
251			darkercolor.a = 0.99;
252			darkercolor.fillColor = rgbaString(darkercolor);
253			} else if (stringcolor.fillColor.indexOf("hsl") !== -1) {
254			darkercolor.h = stringcolor.h;
255			darkercolor.s = stringcolor.s;
256			darkercolor.l = factor * stringcolor.l - 30;
257			darkercolor.fillColor = hslaString(darkercolor);
258			}
259
260			return darkercolor;
261			}
262
263			export function getColors(options) {
264			let color0, color1;
265			if (options.index !== undefined && options.count > 0) {
266			color0 = getColor(options.index, options.count);
267			color1 = getColor1();
268			} else {
269			let deccolor = toDecColor(options.color);
270			color0 = deccolor.fillColor;
271			color1 = darken(deccolor).fillColor;
272			}
273			return [color0, color1];
274			}
275

HuasoFoundries / ig_markerfactory

parsers.js ➔ parseRGB A last analyzed 2018-11-12 22:15 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

parsers.js ➔ parseRGB A
last analyzed 2018-11-12 22:15 UTC